%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% vim:enc=utf-8:ts=5:sw=5:et:ff=unix:
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\chapter{Editando}
\label{Editando}
\index{editando}A principal função de um editor de textos é editar textos. 
Parece óbvio, mas em meio a inúmeros recursos extras essa simples e crucial
função perde-se entre todos os demais.

\section{Abrindo o arquivo para a edição}
Portanto, a primeira coisa a fazer é abrir um arquivo.
Como visto, para abrir um arquivo\index{iniciar} com Vim, digite em um terminal:
%
\begin{verbatim}
     vim texto.txt
\end{verbatim}
onde {\tt texto.txt} é o nome do arquivo que deseja-se criar ou editar.

Caso deseje abrir o arquivo na linha 10\index{iniciar!linha específica}, usa-se:
\begin{verbatim}
     vim +10 /caminho/para/o/arquivo
\end{verbatim}
se quiser abrir o arquivo na linha que contém um determinado padrão
\index{iniciar!padrão específico}, digite:
\begin{verbatim}
     vim +/padrão arquivo
\end{verbatim}

{\Large {\ding{45}}} Caso o padrão tenha espaços no nome coloque entre aspas ou
use {\em escape} ``$\backslash$'' a fim de não obter erro.  

{\Large \ding{45}} Se o vim for aberto sem indicação de arquivo pode-se indicar
o arquivo a ser editado em modo de comando desta forma:

\begin{verbatim}
    :e /home/usuario/arquivo
\end{verbatim}

\section{Escrevendo o texto}
O Vim é um editor que possuí diferentes modos de edição. Entre eles está o modo
de inserção, que é o modo onde escreve-se o texto naturalmente.

Para se entrar em modo de inserção, estando em modo normal, pode-se pressionar 
qualquer uma das teclas abaixo:
\index{modos de operação}
\begin{verbatim}
     i ..... entra no modo de inserção antes do caractere atual
     I ..... entra no modo de inserção no começo da linha
     a ..... entra no modo de inserção após o caractere atual
     A ..... entra no modo de inserção no final da linha
     o ..... entra no modo de inserção uma linha abaixo
     O ..... entra em modo de inserção uma linha cima
     <Esc> . sai do modo de inserção
\end{verbatim}

Uma vez no modo de inserção\index{modo de inserção} todas as teclas são exatamente 
como nos outros editores simples, caracteres que constituem o conteúdo do texto 
sendo digitado. 
O que inclui as teclas de edição de caracteres.

Para salvar\index{salvar o texto} o conteúdo escrito, digite a tecla
\verb|<Esc>| para sair do modo de inserção e digite o comando `\texttt{:w}'
para gravar o conteúdo.  Caso queira sair do editor\index{fechar o programa},
digite o comando: `\texttt{:q}' caso tenha ocorrido modificações no arquivo
desde que ele foi salvo pela última vez haverá uma mensagem informando que o
documento foi modificado e não foi salvo, nesse caso, digite o comando `\texttt{:q!}
para fechar o Vim {\bf sem salvar} as últimas modificações feitas.  
Caso queira salvar e sair do arquivo, digite o comando `\texttt{:wq}'

%Para salvar\index{salvar o texto} o conteúdo escrito, digite a tecla \verb|<Esc>| para 
%sair do modo de inserção e digite o comando:
%\begin{verbatim}
%     :w 
%\end{verbatim}
%para gravar o conteúdo.
%
%Caso queira sair do editor\index{fechar o programa}, digite o comando:
%\begin{verbatim}
%     :q
%\end{verbatim}
%caso tenha ocorrido modificações no arquivo desde que ele foi salvo pela última vez
%haverá uma mensagem informando que o documento foi modificado e não foi salvo,
% nesse caso, digite o comando: 
%\begin{verbatim}
%     :q! 
%\end{verbatim}
%para fechar o Vim {\bf sem salvar} as últimas modificações feitas.
%
%Caso queira salvar e sair do arquivo, digite o comando:
%\begin{verbatim}
%     :wq
%\end{verbatim}

Nesse ponto, conhece-se o vim de forma suficiente para editar
qualquer coisa nele. Daqui por diante o que existe são as formas de
realizar a edição do arquivo com maior naturalidade e produtividade.

O usuário iniciante do Vim pode cometer o erro de tentar decorar 
todos os comandos que serão apresentados. {\bf Não faça isso}. Tentar decorar
comando é exatamente o caminho contrário da naturalidade exigida por 
um editor texto para aumentar a produtividade.

Ao contrário, sugere-se que leia-se todo o conteúdo. Identifique 
quais são as atividades de maior recorrência no estilo individual de 
escrita e busque como realizar tais funções com mais fluência nesse
editor. A prática levará ao uso de fluente desse comandos principais,
abrindo espaço para os demais comandos.

Isso não impede que o usuário experimente cada comando conforme for lendo.
De fato, essa prática pode ajudar a selecionar as formas de edição que lhe
são mais simpáticas ao uso.

\section{Copiar, Colar e Deletar}\label{sec:CopiarColarEDeletar}
\vimhelp{delete, d}
\index{deletar}
No modo normal, o ato de deletar ou eliminar o texto está associado
à letra ``\verb|d|''. No modo de inserção as teclas usuais também 
funcionam.

%ORIGINAL: Parte do texto fica fora da margem
%\begin{verbatim}
%     dd .... deleta linha atual
%     D ..... deleta restante da linha
%     d$ .... deleta do ponto atual até o final da linha
%     d^ .... deleta do cursor ao primeiro caractere não-nulo da linha
%     d0 .... deleta do cursor ao início da linha
%\end{verbatim}
%
%Modificado Tipo 1: colocando todo mundo dentro da margem com um ENTER
\begin{verbatim}
     dd .... deleta linha atual
     D ..... deleta restante da linha
     d$ .... deleta do ponto atual até o final da linha
     d^ .... deleta do cursor ao primeiro caractere não-nulo da 
             linha
     d0 .... deleta do cursor ao início da linha
\end{verbatim}
%
% O uso de tabelas não deu certo porque as tabelas ficavam muito longe do
% ponto citado no texto. Esse feito prejudicava muito a leitura
%Modificado Tipo 2:
%\begin{table}[htb]
%\begin{center}
%\begin{tabular}{ll}
%\hline
%\verb|dd| & deleta linha atual \\
%\verb|D|  & deleta restante da linha \\
%\verb|d$| & deleta do ponto atual até o final da linha \\
%\mr{2}{*}{\texttt{d\^}} &  deleta do cursor ao primeiro caractere não-nulo da \\
%                          & linha \\ 
%\verb|d0| & deleta do cursor ao início da linha \\ \hline
%\end{tabular}
%\end{center}
%\end{table} 
%
%Contudo, como a tabela acima não tem tamanho fixo na fonte para a descrição, pode-se fazer
%\begin{table}[htb]
%\begin{center}
%\begin{tabular}{ll}
%\hline
%\verb|dd| & deleta linha atual \\
%\verb|D|  & deleta restante da linha \\
%\verb|d$| & deleta do ponto atual até o final da linha \\
%\verb|d^| & deleta do cursor ao primeiro caractere não-nulo da linha \\ 
%\verb|d0| & deleta do cursor ao início da linha \\ \hline
%\end{tabular}
%\end{center}
%\end{table} 

{\Large \ding{45}} Pode-se combinar o comando de deleção ``\verb+d+'' com o
comando de movimento (considere o modo normal) para apagar até a
próxima vírgula use: ``\verb+df,+''. 

\index{copiar}Copiar está associado à letra ``\verb|y|''.

\begin{verbatim}
     yy .... copia a linha atual
     Y ..... copia a linha atual
     ye .... copia do cursor ao fim da palavra
     yb .... copia do começo da palavra ao cursor
\end{verbatim}

O que foi deletado ou copiado pode ser colado\index{colar}:
\begin{verbatim}
     p .... cola o que foi copiado ou deletado abaixo
     P .... cola o que foi copiado ou deletado acima
     [p ... cola o que foi copiado ou deletado antes do cursor
     ]p ... cola o que foi copiado ou deletado após o cursor
\end{verbatim}

\subsection{Deletando uma parte do texto}\label{Deletando uma parte do texto}
\vimhelp{deleting}

\index{deletar}O comando `{\tt d}' remove o conteúdo para a memória.

\begin{verbatim}
     x .... apaga o caractere sob o cursor
     xp ... troca letras de lugar
     ddp .. troca linhas de lugar
     d5x .. apaga os próximos 5 caracteres
     dd  .. apaga a linha atual
     5dd .. apaga 5 linhas (também pode ser: d5d)
     d5G .. apaga até a linha 5
     dw  .. apaga uma palavra
     5dw .. apaga 5 palavras (também pode ser: d5w)
     dl  .. apaga uma letra (sinônimo: x)
     5dl .. apaga 5 letras (também pode ser: d5l ou 5x)
     d0  .. apaga até o início da linha
     d^  .. apaga até o primeiro caractere da linha
     d$  .. apaga até o final da linha (sinônimo: D)
     dgg .. apaga até o início do arquivo
     dG  .. apaga até o final do arquivo
     D .... apaga o resto da linha
     d% ... deleta até o próximo (,[,{
     da" .. deleta aspas com conteúdo
\end{verbatim}

Depois do texto ter sido colocado na memória, digite `{\tt p}' para `inserir' o
texto em uma outra posição. Outros comandos:

\begin{verbatim}
     diw .. apaga palavra mesmo que não esteja posicionado no 
            início
     dip .. apaga o parágrafo atual
     d4b .. apaga as quatro palavras anteriores
     dfx .. apaga até o próximo ``x''
     d/casa/+1 - deleta até a linha após a palavra casa
\end{verbatim}

Trocando a letra `{\tt d}' nos comandos acima por `{\tt c}' de {\em change}
``mudança'' ao invés de deletar será feita uma mudança de conteúdo.  Por
exemplo:
\vimhelp{change}

\begin{verbatim}
     ciw .............. modifica uma palavra
     cip .............. modifica um parágrafo
     cis .............. modifica uma sentença
     C ................ modifica até o final da linha
\end{verbatim}

\subsection{Copiando sem deletar}\label{Copiando sem deletar}
\vimhelp{yank}

\index{copiar}O comando `{\tt y}' ({\em yank}) permite copiar uma parte do 
texto para a memória sem deletar.  Existe uma semelhança muito grande entre 
os comandos `{\tt y}' e os comandos `{\tt d}', um ativa a `cópia' e outro a 
`exclusão' de conteúdo, suportando ambos quantificadores:

\begin{verbatim}
     yy  .... copia a linha atual (sinônimo: Y)
     5yy .... copia 5 linhas (também pode ser: y5y ou 5Y)
     y/pat .. copia até `pat'
     yw  .... copia uma palavra
     5yw .... copia 5 palavras (também pode ser: y5w)
     yl  .... copia uma letra
     5yl .... copia 5 letras (também pode ser: y5l)
     y^  .... copia da posição atual até o início da linha
              (sinônimo: y0)
     y$  .... copia da posição atual até o final da linha
     ygg .... copia da posição atual até o início do arquivo
     yG  .... copia da posição atual até o final do arquivo
\end{verbatim}

Digite `{\tt P}' (p maiúsculo) para \index{colar}colar o texto recém copiado na
posição onde encontra-se o cursor, ou `{\tt p}' para colar o texto na posição 
imediatamente após o cursor.

\begin{verbatim}
     yi" .... copia trecho entre aspas (atual - inner)
     vip .... seleção visual para parágrafo atual 
              `inner paragraph'
     yip .... copia o parágrafo atual
     yit .... copia a tag agual `inner tag' útil para arquivos 
              HTML, XML, etc.
\end{verbatim}

\subsection{Usando a área de transferência {\em Clipboard}}
\vimhelp{paste, clipboard, quoteplus}

\index{copiar}\index{colar}\index{clipboard}
\index{área de transferência}Exemplos para o modo visual:

\begin{verbatim}
     Ctrl-insert .... copia área selecionada 
     Shift-insert ... cola o que está no clipboard
     Ctrl-del ....... recorta para o clipboard
\end{verbatim}

Caso obtenhamos erro ao colar textos da área de transferência usando os
comandos acima citados podemos usar outra alternativa.  Os comandos abaixo
preservam a indentação\footnote{Espaçamento entre o começo da linha e o início
do texto}.

\begin{verbatim}
     "+p ............ cola preservando indentação
     "+y ............ copia área selecionada
\end{verbatim}

{\Large \ding{45}} Para evitar erros ao colar usando {\tt Shift-insert} 
use este comando `{\tt :set paste}'.

\subsection{Removendo linhas duplicadas}
\index{deletar!linhas duplicadas}
\begin{verbatim}
     :sort u
\end{verbatim}

\section{Forçando a edição de um novo arquivo}\label{sec:Forçando a edição de um novo arquivo}
\vimhelp{edit!}

\index{iniciar!novo arquivo}
O Vim, como qualquer outro editor, é muito exigente no que se refere a alterações
de arquivo.  Ao tentar abandonar um arquivo editado e não salvo, o Vim irá se certificar
da ação. Para abrir um novo arquivo sem salvar o antigo:

\begin{verbatim}
     :enew!
\end{verbatim}

O comando acima é uma abreviação de {\em edit new}. De modo similar pode-se
ignorar todas as alterações feitas desde a abertura do arquivo:

\begin{verbatim}
     :e!
\end{verbatim}

\section{Ordenando}\index{ordenando}
\vimhelp{sort}

O Vim, versão 7 ou superior, passa a ter um comando de ordenação que também 
permite a retirada de linhas duplicadas, tal como foi apresentado.

\begin{verbatim}
     :sort u ... ordena e retira linhas duplicadas
     :sort n ... ordena numericamente
\end{verbatim}

Obs: a ordenação numérica é diferente da ordenação alfabética se em um
trecho contendo algo como:

\begin{verbatim}
     8
     9
     10
     11
     12
\end{verbatim}

Você tentar fazer:

\begin{verbatim}
     :sort
\end{verbatim}

O Vim colocará nas três primeiras linhas

\begin{verbatim}
     10
     11
     12
\end{verbatim}

Portanto lembre-se que se a ordenação envolver números use:

\begin{verbatim}
     :sort n
\end{verbatim}

Você pode fazer a ordenação em um intervalo assim:

\begin{verbatim}
     :1,15 sort n
\end{verbatim}

O comando acima diz ``{\em Ordene numericamente da linha 1 até a linha 15}''.  
Podemos ainda ordenar à partir de uma coluna:

\begin{verbatim}
     :sort /.*\%8v/   ..... ordena à partir do 8º caractere
\end{verbatim}

\section{Usando o \texttt{grep} interno do Vim}
\label{sec:Usando o grep interno do Vim}\index{grep}
\vimhelp{vimgrep, lvimgrep}

Para editar todos os arquivos que contenham a palavra ``inusitada'':

\begin{verbatim}
    :vimgrep /\cinusitada/ *
\end{verbatim}
a opção `\verb|\c|' torna a busca indiferente a letras maiúsculas e minúsculas.

Obs: o Vim busca à partir do diretório atual, para se descobrir 
o diretório atual ou mudá-lo:

\begin{verbatim}
    :pwd ........... exibe o diretório atual
    :cd /diretório   muda de diretório
\end{verbatim}

\section{Lista de alterações}\index{lista de alterações}\index{histórico}
\vimhelp{changelist, changes}

O Vim mantém uma lista de alterações, veremos agora como usar este recurso.

\begin{verbatim}
     g, ................. avança na lista de alterações
     g; ................. recua na lista de alterações
     :changes ........... visualiza a lista de alterações
\end{verbatim}

\section{Substituindo tabulações por espaços}
\label{sec:Substituindo tabulações por espaços}
\vimhelp{expandtab, retab}

Se houver necessidade\footnote{Em códigos Python por exemplo não se pode
misturar espaços e tabulações} de trocar tabulações por espaços
fazemos assim:

\begin{verbatim}
      :set tabstop=4 "tamanho da parada de tabulação
	 :set expandtab
	 :retab
\end{verbatim}

Para fazer o contrário usamos algo como:

\begin{verbatim}
    :%s/\s\{4,}/<pressiona-se ctrl-i>/g
\end{verbatim}
onde
\begin{verbatim}
    <Ctrl-i>...... insere uma tabulação
\end{verbatim}

Explicando:
\begin{verbatim}
    : ............ comando
    % ............ em todo arquivo 
    s ............ substitua 
    / ............ padrão de busca
    \s ........... localiza espaço
    \{4,} ........ quatro vezes
    / ............ inicio da substituição
    <Ctrl-i> ..... pressione Ctrl-i para inserir <Tab>
    / ............ fim da substituição
    g ............ global
\end{verbatim}

\section{Convertendo para maiúsculas}
\label{sec:Convertendo para maiúsculas}
\vimhelp{case}

\begin{verbatim}
     gUU ....... converte a linha para maiúsculo
     guu ....... converte a linha para minúsculo
     gUiw ...... converte a palavra atual para maiúsculo
     ~ ......... altera o case do caractere atual
\end{verbatim}

\section{Editando em modo de comando}
\label{sec:Editando em modo de comando}
\vimhelp{put, move, global, holy-grail}

Para mover um trecho usando o modo de comandos faça:

\begin{verbatim}
     :10,20m $
\end{verbatim}

O comando acima move `{\tt m}' da linha 10 até a linha 20 para o final \verb|$|.

\begin{verbatim}
     :g /palavra/ m 0
\end{verbatim}

Move as linhas contendo `palavra' para o começo (linha zero)


\begin{verbatim}
     :10,20y a
\end{verbatim}

Copia da linha `10' até a linha `20' para o registro `a'

\begin{verbatim}
     :56pu a
\end{verbatim}

Cola o registro `a' na linha 56

\begin{verbatim}
     :g/padrão/d
\end{verbatim}

O comando acima deleta todas as linhas contendo a palavra `padrão'.

Podemos inverter a lógica do comando global \verb+g+:

\begin{verbatim}
     :g!/padrão/d
\end{verbatim}

Não delete as linhas contendo padrão, ou seja, delete tudo menos as linhas
contendo a palavra `padrão'. 

\begin{verbatim}
     :v/padrão/d ........ apaga linhas que não contenham "padrão"
     :v/\S/d ............ apaga linhas vazias
     \S ................. significa "string"
\end{verbatim}

A opção acima equivale a ``\verb+:g!/padrão/d+''.  Para ler mais sobre
o comando ``global'' utilizado nesta seção veja o capítulo~\ref{sec:O comando global ``g''}.

\begin{verbatim}
     :7,10copy $
\end{verbatim}

Da linha 7 até a linha 10 copie para o final. {\Large \ding{45}}
Veja mais sobre edição no modo de comando na seção ``\ref{cha:Buscas e
substituições} Buscas e substituições na página~\pageref{cha:Buscas e substituições}''.

\subsubsection{Gerando sequências}
Para inserir uma sequência de 1 a 10 à partir da linha inicial ``zero'' fazemos:

\begin{verbatim}
     :0put =range(1,10)
\end{verbatim}

Caso queira inserir sequências como esta:

\begin{verbatim}
     192.168.0.1
     192.168.0.2
     192.168.0.3
     192.168.0.4
     192.168.0.5
\end{verbatim}

Usamos este comando:

\begin{verbatim}
     :for i in range(1,5) | .put ='192.168.0.'.i | endfor
\end{verbatim}

\section{O arquivo alternativo}
\label{O arquivo alternativo}
\vimhelp{Ctrl-6, alternate-file}

É muito comum um usuário concluir a edição em um arquivo no Vim e
inocentemente imaginar que não vai mais modificar qualquer coisa nele, então
este usuário abre um novo arquivo:

\begin{verbatim}
     :e novo-arquivo.txt
\end{verbatim}

Mas de repente o usuário lembra que seria necessário adicionar uma linha no
arquivo recém editado, neste caso usa-se o atalho

\begin{verbatim}
     Ctrl-6
\end{verbatim}

cuja função é alternar entre o arquivo atual e o último editado. Para retornar
ao outro arquivo basta portanto pressionar \verb|Ctrl-6| novamente. Pode-se 
abrir o arquivo alternativo em nova janela usando-se o atalho:

\begin{verbatim}
    Ctrl-w Ctrl-6
\end{verbatim}

{\Large \ding{45}} Mais informações sobre ``janelas'' leia a seção \ref{cha:Trabalhando com janelas} na 
página \pageref{cha:Trabalhando com janelas}.

\section{Lendo um arquivo para a linha atual}
\label{sec:Lendo um arquivo para a linha atual}
\vimhelp{:r[ead]}

Se desejamos inserir na linha atual um arquivo qualquer fazemos:

\begin{verbatim}
	 :r /caminho/para/arquivo.txt .. insere o arquivo na linha atual
	 :0r arquivo ................... insere o arquivo na primeira 
                                    linha
\end{verbatim}


\section{Incrementando números em modo normal}\label{Incrementando números em modo normal}
\vimhelp{Ctrl-a, Ctrl-x}

Posicione o cursor sobre um número e pressione

\begin{verbatim}
     Ctrl-a ..... incrementa o número
     Ctrl-x ..... decrementa o número
\end{verbatim}

\section{Repetindo a digitação de linhas}
\label{Repetindo a digitação de linhas}

\begin{verbatim}
     " atalhos para o modo insert
     Ctrl-y ......... repete linha acima
     Ctrl-e ......... repete linha abaixo
     Ctrl-x Ctrl-l .. repete linhas inteiras
     Ctrl-a ......... repete a última inserção
\end{verbatim}

{\Large \ding{45}} Para saber mais sobre repetição de comandos veja o capítulo
\ref{Repetição de comandos}, na página \pageref{Repetição de comandos}.

\section{Movendo um trecho de forma inusitada}
\label{Movendo um trecho de forma inusitada}

\begin{verbatim}
     :20,30m 0 ..... move da linha `20' até `30' para o começo
     :20,/pat/m 5 .. move da linha `20' até `pat' para a linha 5
     :m-5 .......... move a linha atual 5 posições acima
     :m0 ........... move a linha atual para o começo
     :m$ ........... move para o final do documento
\end{verbatim}

\section{Uma calculadora diferente}
\label{Uma calculadora diferente}

Sempre que for necessário digitar  o resultado de uma expressão matemática
(portanto no modo de inserção) pode-se usar o atalho ``{\tt Ctrl-r =}'', ele
ativa o registro de expressões, na linha de comando do Vim aparece um sinal de
igual, digita-se então uma expressão matemática qualquer tipo ``{\tt 35*6}'' e
em seguida pressiona-se ``{\tt Enter}'', o Vim coloca então o resultado da
expressão no lugar desejado.  Portanto não precisa-se recorrer a nenhuma
calculadora para fazer cálculos.  Pode-se fazer uso do ``Registro de
Expressões'' dentro de macros, ou seja, ao gravar ações pode-se fazer uso deste
recurso, aumentando assim sua complexidade e poder! Para ler sobre ``macros''
acesse a seção \ref{sec:Gravando comandos} na \pageref{sec:Gravando comandos}.
Para saber mais sobre o ``registro de expressões'' leia a seção
\ref{sec:Registro de expressões "=} na página~\pageref{sec:Registro de expressões "=}.

{\Large {\ding{45}}} Na seção \ref{sec:Calculadora Científica com o Vim}
``Calculadora Científica com o vim'' página~\pageref{sec:Calculadora Científica com
o Vim} há uma descrição sobre como fazer cálculos com maior precisão e
complexidade.

{\Large {\ding{45}}} Se a intenção for apenas exibir um calculo na barra de comandos
é possível fazer algo assim:

\begin{verbatim}
    :echo 5.2 * 3
\end{verbatim}

\section{Desfazendo}
\label{Desfazendo}
\vimhelp{undo}

Se você cometer um erro, não se preocupe! Use o comando `{\tt u}':

\begin{verbatim}
     u ............ desfazer
     U ............ desfaz mudanças na última linha editada
     Ctrl-r  ...... refazer
\end{verbatim}

\subsection{{\em Undo tree}}
\label{Undo tree}

Um novo recurso muito interessante foi adicionado ao Vim ``a partir da
versão 7''  é a chamada árvore do desfazer.  Se
você desfaz alguma coisa, fez uma alteração um novo {\em branch} ou
galho, derivação de alteração é criado.  Basicamente, os {\em branches}
nos permitem acessar quaisquer alterações ocorridas no arquivo.

\subsubsection{Um exemplo didático}
\label{Um exemplo didático}

Siga estes passos (para cada passo \verb|<Esc>|, ou seja, saia do modo
de inserção)

\begin{description}
\item [Passo 1] - digite na linha 1 o seguinte texto
\begin{verbatim}
     # controle de fluxo <Esc>
\end{verbatim}

\item [Passo 2] - digite na linha 2 o seguinte texto
\begin{verbatim}
     # um laço for <Esc>
\end{verbatim}

\item [Passo 3] - Nas linhas 3 e 4 digite...

\begin{verbatim}
     for i in range(10):
         print i  <Esc>
\end{verbatim}

\item [Passo 4] - pressione `{\tt u}' duas vezes (você voltará ao passo 1)
\item [Passo 5] - Na linha 2 digite

\begin{verbatim}
     # operador ternário <Esc>
\end{verbatim}

\item [Passo 6] - na linha 3 digite

\begin{verbatim}
     var = (1 if teste == 0 else 2)  <Esc>
\end{verbatim}

\end{description}

Obs: A necessidade do {\tt Esc} é para demarcar as ações, pois o Vim
considera cada inserção uma ação.  Agora usando o atalho de desfazer
tradicional ``u'' e de refazer {\tt Ctrl-r} observe que não é mais possível
acessar todas as alterações efetuadas. Em resumo, se você fizer uma
nova alteração após um desfazer (alteração derivada) o comando refazer
não mais vai ser possível para aquele momento. 

Agora volte até a alteração 1 e use seguidas vezes:

\begin{verbatim}
     g+
\end{verbatim}

e/ou

\begin{verbatim}
     g-
\end{verbatim}

Dessa forma você acessará todas as alterações ocorridas no texto.


\subsection{{\em Máquina do tempo}}
\label{Máquina do tempo}

O Vim possui muitas formas para desfazer e refazer, e uma das mais interessantes é a máquina do tempo!
A máquina do tempo é extremamente útil quando no meio de um texto se percebe que boa parte do que foi adicionado
é inútil e que nos ultimos 10 minutos não há nada que se possa aproveitar. Utilizando a máquina do tempo
é possível eliminar os últimos 10 minutos de texto inútil do seu documento facilmente, utilizando:

\begin{verbatim}
    :earlier 10m
\end{verbatim}

Com esse comando o documento ficará exatamente como ele estava 10 minutos atrás!
Caso após a exclusão perceba-se que foi excluído um minuto a mais, é possível utilizar o mesmo padrão novamente para avançar no tempo:
         
\begin{verbatim}
    :later 60s
\end{verbatim}
                  
Note que dessa vez foi utilizado {\em later} ao invés de {\em earlier}, e passando segundos como argumento para viajar no tempo.
Portanto o comando acima avança 60 segundos no tempo.

Para uma melhor visão de quanto se deve voltar, pode ser usado o comando:
                  
\begin{verbatim}
    :undolist
\end{verbatim}
                           
O comando acima mostra a lista com as informações sobre Desfazer e Refazer. E com essas informações pode-se voltar no tempo seguindo
cada modificação:

\begin{verbatim}
    :undo 3
\end{verbatim}
                                    
Esse comando fará o documento regredir 3 modificações.

\section{Salvando}
\label{sec:Salvando}
\vimhelp{writing}

A maneira mais simples de salvar um arquivo, é usar o comando:

\begin{verbatim}
     :w
\end{verbatim}


Para especificar um novo nome para o arquivo, simplesmente digite:

\begin{verbatim}
     :w! >> ``file''
\end{verbatim}

O conteúdo será gravado no arquivo ``{\tt file}'' e você continuará no arquivo original.

Também existe o comando

\begin{verbatim}
     :sav[eas] nome
\end{verbatim}

salva o arquivo com um novo nome e muda para esse novo arquivo (o arquivo
original não é apagado).  Para sair do editor, salvando o arquivo atual, digite
{\tt :x} (ou {\tt :wq}).

\begin{verbatim}
     :w ............................ salva
     :wq  .......................... salva e sai
     :w nome ....................... salvar como
     :saveas nome .................. salvar como
     :sav nome ..................... mesmo que "saveas nome"
     :x ............................ salva se existirem 
                                     modificações
     :10,20 w! ~/Desktop/teste.txt . salva um trecho para outro 
                                     arquivo
     :w! ........................... salvamento forçado
     :e! ........................... reinicia a edição ignorando 
                                     alterações
\end{verbatim}


\section{Abrindo o último arquivo rapidamente}

O Vim guarda um registro para cada arquivo editado veja
mais no capítulo \ref{Registros} na página \pageref{Registros}.

\begin{verbatim}
     '0 ........ abre o último arquivo editado
     '1 ........ abre o penúltimo arquivo editado
     Ctrl-6 .... abre o arquivo alternativo (booleano)
\end{verbatim}

Bom, já que abrimos o nosso último arquivo editado com o comando

\begin{verbatim}
     `0
\end{verbatim}

podemos, e provavelmente o faremos, editar no mesmo ponto em que estávamos
editando da última vez:

\begin{verbatim}
     gi
\end{verbatim}

{\Large \ding{45}} Pode-se criar um `{\tt alias}'\footnote{Abreviação para um
comando do GNU/Linux} para que ao abrir o vim o mesmo abra o último arquivo
editado: `\verb|alias lvim="vim -c \"normal '0\""|'.  No capítulo
\ref{cha:Buscas e substituições} página \pageref{cha:Buscas e substituições}
você encontra mais dicas de edição.


\section{Modelines}\label{sec:Modelines}
\vimhelp{modeline}

São um modo de guardar preferências no próprio arquivo, suas
preferências viajam literalmente junto com o arquivo, basta usar em
uma das 5 primeiras linhas ou na última linha do arquivo algo
como:

\begin{verbatim}
     # vim:ft=sh:
\end{verbatim}

OBS: Você deve colocar um espaço entre a palavra `{\tt vim}' e a primeira
coluna, ou seja, a palavra `{\tt vim}' deve vir precedida de um espaço, daí
em diante cada opção fica assim:

\begin{verbatim}
     :opção:
\end{verbatim}

Por exemplo: posso salvar um arquivo com extensão \verb|.sh| e dentro do
mesmo indicar no {\em modeline} algo como:

\begin{verbatim}
     # vim:ft=txt:nu:
\end{verbatim}

Apesar de usar a extensão `{\tt sh}' o Vim reconhecerá este arquivo como `{\tt txt}', e
caso eu não tenha habilitado a numeração, ainda assim o Vim usará por causa da
opção `{\tt nu}'.  Portanto o uso de {\em modelines} pode ser um grande recurso para o seu
dia-a-dia pois você pode coloca-las dentro dos comentários!

\section{Edição avançada de linhas}

Seja o seguinte texto:

\begin{verbatim}
     1  este é um texto novo
     2  este é um texto novo
     3  este é um texto novo
     4  este é um texto novo
     5  este é um texto novo
     6  este é um texto novo
     7  este é um texto novo
     8  este é um texto novo
     9  este é um texto novo
     10 este é um texto novo
\end{verbatim}

Suponha que queira-se apagar ``{\tt é um texto}'' da linha 5 até o fim (linha
10). Isto pode ser feito assim:

\begin{verbatim}
     :5,$ normal 0wd3w
\end{verbatim}

Explicando o comando acima:

\begin{verbatim}
     :5,$ .... indica o intervalo que é da linha 5 até o fim `$'
     normal .. executa em modo normal
     0 ....... move o cursor para o começo da linha
     w ....... pula uma palavra
     d3w ..... apaga 3 palavras `w'
\end{verbatim}

Obs: É claro que um comando de substituição simples

\begin{verbatim}
     :5,$s/é um texto//g
\end{verbatim}

Resolveria neste caso, mas a vantagem do método anterior é que
é válido para três palavras, sejam quais forem.  
Também é possível empregar comandos de inserção como `{\tt i}' ou `{\tt a}' e
retornar ao modo normal, bastando para isso usar o recurso \verb|Ctrl-v Esc|,
de forma a simular o acionamento da tecla \verb|Esc| (saída do modo de
inserção). Por exemplo, suponha agora que deseja-se mudar a frase ``{\em este
é um texto novo}'' para ``{\em este não é um texto velho}''; pode ser feito
assim:

\begin{verbatim}
     :5,$ normal 02winão ^[$ciwvelho
\end{verbatim}

Decompondo o comando acima temos:

\begin{verbatim}
     :5,$ .... indica o intervalo que é da linha 5 até o fim `$'
     normal .. executa em modo normal
     0 ....... move o cursor para o começo da linha
     2w ...... pula duas palavras (vai para a palavra "é")
     i ....... entra no modo de inserção
     não  .... insere a palavra "não" seguida de espaço " "
     ^[ ...... sai do modo de inserção (através de Ctrl-v seguido 
               de Esc)
     $ ....... vai para o fim da linha
     ciw ..... apaga a última palavra ("novo") e entra em modo de 
               inserção
     velho ... insere a palavra "velho" no lugar de "novo"
\end{verbatim}

A combinação \verb|Ctrl-v| é utilizada para inserir caracteres de controle na
sua forma literal, prevenindo-se assim a interpretação destes neste exato
momento.

\section{Comentando rapidamente um trecho}

Tomando como exemplo um trecho de código como abaixo:

\begin{verbatim}
     1   input{capitulo1}
     2   input{capitulo2}
     3   input{capitulo3}
     4   input{capitulo4}
     5   input{capitulo5}
     6   input{capitulo6}
     7   input{capitulo7}
     8   input{capitulo8}
     9   input{capitulo9}
\end{verbatim}

Se desejamos comentar da linha 4 até a linha 9 podemos fazer:

\begin{verbatim}
     posicionar o cursor no começo da linha 4
     Ctrl-v ........... inicia seleção por blocos
     5j ............... estende a seleção até o fim
     Shift-i .......... inicia inserção no começo da linha
     % ................ insere comentário (LaTeX)
     Esc .............. sai do modo de inserção
\end{verbatim}

\section{Comparando arquivos com o vimdiff}
\label{sec:Comparando arquivos com o vimdiff}

\vimhelp{diff}

O vim possui um modo para checagem de diferenças entre arquivos, é bastante
útil especialmente para programadores, para saber quais
são as diferenças entre dois arquivos faz-se:

\begin{verbatim}
    vimdiff arquivo1.txt arquivo2.txt .. exibe as diferenças
    ]c ................................. mostra próxima diferença
    vim -d ............................. outro modo de abrir o 
                                         vimdiff mode
\end{verbatim}

Para usuários do GNU/Linux é possível ainda checar diferenças remotamente assim:

\begin{verbatim}
    vimdiff projeto scp://usuario@estacao//caminho/projeto
\end{verbatim}

O comando acima irá exibir lado a lado o arquivo local chamado `{\tt projeto}' e o 
arquivo remoto contido no computador de nome `{\tt estacao}' de mesmo nome.


